/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package ourpkr.controler;

import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
import ourpkr.model.EnsembleCartes;
import ourpkr.model.joueur.Joueur;
import com.sampullara.poker.*;
import java.util.ArrayList;
import java.util.Collections;
import ourpkr.OurPkrApp;
import java.beans.*;

/**
 *
 * @author niboucha
 */
public class Tour {
    
    private EnsembleCartes paquet;
    private String progress;

    public String getProgress() {
        return progress;
    }
    private String partieRes;

    public void setPartieRes(String partieRes) {
        String old = this.partieRes;
        this.partieRes = partieRes;
        pcs.firePropertyChange("partieRes",old,this.partieRes);
    }

    public void setProgress(String progress) {
        String old = this.progress;
        this.progress = progress;
        pcs.firePropertyChange("progress",old,this.progress);
    }

    public void setTapis(EnsembleCartes tapis) {
        EnsembleCartes old = this.tapis;
        this.tapis = tapis;
        pcs.firePropertyChange("tapis",old,this.tapis);
    }
    private EnsembleCartes tapis;
    private boolean bruler;
    private int mainPot = 0;
    
    public PropertyChangeSupport pcs;

    public void setMainPot(int mainPot) {
        int old = this.mainPot;
        this.mainPot = mainPot;
        pcs.firePropertyChange("mainPot", old, this.mainPot);
    }
    public int bBlind = 10;
    
    public Tour(){
        pcs = new PropertyChangeSupport(this);
        paquet = new EnsembleCartes(true);
        paquet.mix();
        bruler = Math.random() > 0.5 ? true : false;
        
    }
    
    public EnsembleCartes getTapis()
    {
        return tapis;
    }
    
    public int getMainPot()
    {
        return mainPot;
    }

    private void initPlayers(Vector<Joueur> joueurs) {
        for(int i = 0 ; i< joueurs.size() ; i ++){
            joueurs.get(i).setAlwaysInTour(true);
            joueurs.get(i).setDealer(false);
        }
        setPartieRes("");
    }
    
    private void initTapis() {
       setTapis(new EnsembleCartes(false));
    }
    
    public void joue(){
        Vector<Joueur> joueurs = OurPkrApp.getApplication().getPc().getJoueurs();
        initTapis();
        initPlayers(joueurs);
        initialiserMains(joueurs);
        distribuerCartes(joueurs);
        
        /*pose des blinds*/
        joueurs.get(joueurs.size()-1).setMiseCourante(bBlind);       
        joueurs.get(joueurs.size()-2).setMiseCourante(bBlind/2);
        joueurs.get(0).setDealer(true);
        setProgress("1er Tour d'encheres");
        (new Coup()).joue();
        setProgress("Flop");
        poserCartes(3);
        (new Coup()).joue();
        setProgress("Turn");
        poserCartes(1);
        (new Coup()).joue();
        setProgress("River");
        poserCartes(1);
        (new Coup()).joue();
        setProgress("Tour termine");
        determinerGagnant(joueurs);
    }
    
    private void distribuerCartes(Vector<Joueur> joueurs){
        for(int i = 0; i < 2 ; i++){
            for(int j = 0 ; j < joueurs.size() ; j++){
                joueurs.get(j).getMain().addACarte(paquet.removeACarte(0));
            }
        }
    }
    
    private void initialiserMains(Vector<Joueur> joueurs)
    {
        for(int i = 0 ; i < joueurs.size() ; i++){
                joueurs.get(i).setMain(new EnsembleCartes(false));
        }
    }
    
    
   private void afficherMains(Vector<Joueur> joueurs)
   {
       for(int i = 0 ; i < joueurs.size() ; i++){
                System.out.println(joueurs.get(i)+" = ");
                System.out.println(joueurs.get(i).getMain());
        }
   }
    
    private void poserCartes(int nb){
        if (bruler) {
            paquet.removeACarte(0);
        }
        OurPkrApp.getApplication().getPview().setAnimationMessage("Distribution des cartes");
        OurPkrApp.getApplication().getPview().setAnimationProgress(0);
        for (int i = 0; i < nb; i++) {
            tapis.addACarte(paquet.removeACarte(0));
            OurPkrApp.getApplication().getPview().setAnimationProgress(i * 100 / nb);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException ex) {
                Logger.getLogger(Tour.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        OurPkrApp.getApplication().getPview().setAnimationMessage("");
        OurPkrApp.getApplication().getPview().setAnimationProgress(0);
    }
    
    private synchronized void determinerGagnant(Vector<Joueur> joueurs){
       Vector<Joueur> enLice = new Vector<Joueur>();
       for(Joueur tmp : joueurs){
           if(tmp.isAlwaysInTour()) enLice.add(tmp);
       }
       Vector<Integer> winners = new Vector<Integer>();
       ArrayList<HandRank> hands = new ArrayList<HandRank>();    
       
      for(Joueur tmp : enLice){
         HandRank h = Evaluate.holdem(tmp.getMain().getLibCards(), tapis.getLibCards());
         hands.add(h);
      }
      
      Collections.sort(hands);
      
      HandRank mainGagnante = hands.get( hands.size() - 1 );
      
      for(Joueur tmp : enLice){
          HandRank h = Evaluate.holdem(tmp.getMain().getLibCards(), tapis.getLibCards());
          if( mainGagnante.compareTo(h) != 0 )
          {
                enLice.remove(tmp);
          }
      }
      
      int potADistribuer = mainPot / enLice.size();
      setPartieRes(mainPot+" a distribuer a "+enLice.size()+" gagnants :");
      for( Joueur tmp : enLice)
      {          
          tmp.addToFortune(potADistribuer);
          setMainPot(mainPot-potADistribuer);
          setPartieRes(partieRes+" "+tmp.getNom());
      }
      
      /*for(int i = 0 ; i < joueurs.size() ; i++){
          HandRank h = Evaluate.holdem(joueurs.get(i).getMain().getLibCards(), tapis.getLibCards());
          if( mainGagnante.compareTo(h) == 0 )
          {
              winners.add(i);
          }
      }
      
      int potADistribuer = mainPot / winners.size();
      setPartieRes(mainPot+" a distribuer a "+winners.size()+" gagnants :");
      for( int i = 0 ; i < winners.size() ; i++)
      {          
          joueurs.get( winners.get(i) ).addToFortune(potADistribuer);
          setMainPot(mainPot-potADistribuer);
          setPartieRes(partieRes+" "+joueurs.get(winners.get(i)).getNom());
      }*/
      
      
       
    }
    
  
}
